import json
import logging
from typing import Any, Dict, List, Union

logger = logging.getLogger(__name__)

def parse_task_kwargs(task_kwargs: Any) -> Dict:
    """
    解析task_kwargs字段，处理多重序列化问题
    
    Args:
        task_kwargs: 任务的kwargs参数，可能是字符串、字典或其他类型
        
    Returns:
        Dict: 解析后的字典
    """
    if not task_kwargs:
        return {}
        
    try:
        # 处理多重序列化问题
        # 如果是字符串形式的JSON字符串，先解析一次
        if isinstance(task_kwargs, str):
            # 先尝试直接解析
            try:
                parsed = json.loads(task_kwargs)
                # 如果解析结果还是字符串，可能是多重序列化
                if isinstance(parsed, str):
                    # 替换单引号为双引号，处理Python字典字符串
                    parsed = parsed.replace("'", '"')
                    try:
                        return json.loads(parsed)
                    except json.JSONDecodeError:
                        # 如果还是失败，尝试使用ast.literal_eval
                        import ast
                        try:
                            return ast.literal_eval(parsed)
                        except (SyntaxError, ValueError):
                            return {'raw': parsed}
                else:
                    # 如果已经是字典或列表，直接返回
                    return parsed
            except json.JSONDecodeError:
                # 如果直接JSON解析失败，尝试处理Python字典字符串
                try:
                    import ast
                    return ast.literal_eval(task_kwargs)
                except (SyntaxError, ValueError):
                    # 如果还是失败，返回原始字符串
                    return {'raw': task_kwargs}
        elif isinstance(task_kwargs, dict):
            # 如果已经是字典，直接返回
            return task_kwargs
        else:
            # 其他类型，返回原始值
            return {'raw': task_kwargs}
    except Exception as e:
        logger.error(f"解析task_kwargs失败: {str(e)}")
        return {'error': str(e), 'raw': task_kwargs}


def parse_task_args(task_args: Any) -> List:
    """
    解析task_args字段，处理多重序列化问题
    
    Args:
        task_args: 任务的args参数，可能是字符串、列表或其他类型
        
    Returns:
        List: 解析后的列表
    """
    if not task_args:
        return []
        
    try:
        # 与task_kwargs类似的处理逻辑
        if isinstance(task_args, str):
            try:
                parsed = json.loads(task_args)
                if isinstance(parsed, str):
                    parsed = parsed.replace("'", '"')
                    try:
                        return json.loads(parsed)
                    except json.JSONDecodeError:
                        import ast
                        try:
                            return ast.literal_eval(parsed)
                        except (SyntaxError, ValueError):
                            return [parsed]
                else:
                    return parsed
            except json.JSONDecodeError:
                try:
                    import ast
                    return ast.literal_eval(task_args)
                except (SyntaxError, ValueError):
                    return [task_args]
        elif isinstance(task_args, list):
            return task_args
        else:
            return [task_args]
    except Exception as e:
        logger.error(f"解析task_args失败: {str(e)}")
        return [{'error': str(e), 'raw': task_args}]


def get_task_name_from_kwargs(task_kwargs: Any) -> Union[str, None]:
    """
    从 task_kwargs 中获取任务名称
    
    Args:
        task_kwargs: 任务的kwargs参数
        
    Returns:
        str: 任务名称，如果找不到则返回None
    """
    from tasks.models import Tasks
    
    parsed_kwargs = parse_task_kwargs(task_kwargs)
    if isinstance(parsed_kwargs, dict) and 'tasks_instance_id' in parsed_kwargs:
        task = Tasks.objects.filter(id=parsed_kwargs['tasks_instance_id']).first()
        if task:
            return task.name
    return None


def serialize_for_taskresult(data: Any) -> str:
    """
    将数据序列化为 TaskResult 中存储的格式（双重 JSON 编码）
    
    TaskResult 表中 task_args 和 task_kwargs 字段存储的是双重 JSON 编码的字符串。
    例如：{'rt': 123} -> "{'rt': 123}"
    
    Args:
        data: 要序列化的数据（字典或列表）
        
    Returns:
        str: 双重编码后的字符串
    """
    if not data:
        return json.dumps(json.dumps({} if isinstance(data, dict) else []))
    
    try:
        # 第一次序列化：字典/列表 -> JSON 字符串
        first_encode = json.dumps(data)
        # 第二次序列化：JSON 字符串 -> 转义后的字符串
        second_encode = json.dumps(first_encode)
        return second_encode
    except Exception as e:
        logger.error(f"序列化数据失败: {str(e)}")
        return json.dumps(json.dumps(str(data)))
